⚡️ This pull request contains optimizations for PR #1473

If you approve this dependent PR, these changes will be merged into the original PR branch refactor/tree-sitter-instrumentation.

This PR will be automatically closed if the original PR is merged.

📄 3,150% (31.50x) speedup for JavaAnalyzer._has_test_annotation in codeflash/languages/java/parser.py

⏱️ Runtime : 124 milliseconds → 3.80 milliseconds (best of 5 runs)

📝 Explanation and details

The optimized code achieves a 3150% speedup (from 124ms to 3.8ms) through two key optimizations that dramatically reduce Python attribute lookups and string operations:

1. Caching mod_child.type in a local variable:
The original code called mod_child.type twice - once in the in check and once for each comparison. In Python, attribute access involves dictionary lookups in the object's __dict__, which are expensive when repeated. The optimization caches this in mod_type, cutting the attribute accesses in half. With 2,010 iterations through this hot loop, this eliminates ~2,000 redundant attribute lookups.

2. Short-circuit evaluation with or instead of in operator:
The change from mod_child.type in ("marker_annotation", "annotation") to mod_type == "marker_annotation" or mod_type == "annotation" leverages Python's short-circuit evaluation. The in operator with a tuple requires:

• Creating/accessing the tuple object
• Iterating through tuple elements
• Multiple string comparisons via __eq__

The or expression stops immediately upon finding a match, and benefits from the cached mod_type. Given that the profiler shows this line consumed 98.3% of total time in the original (452ms out of 460ms), this optimization provides the majority of the speedup.

3. Extracting annotation name lookup into _find_test_annotation_name():
While this improves code clarity, it has minimal performance impact since the logic remains the same. However, it makes the code more maintainable without sacrificing the gained performance.

The line profiler confirms the optimization's effectiveness: the critical comparison line dropped from 452ms (98.3% of time) to just 4.9ms (36.4% of time), demonstrating how eliminating redundant operations in tight loops yields dramatic performance improvements in Python code.

✅ Correctness verification report:

To edit these changes git checkout codeflash/optimize-pr1473-2026-02-13T00.33.22 and push.